#!/usr/bin/env python3
"""
全新的分析思路 - 重新分析encript_body.txt
"""

import re
from collections import Counter
import base64

def analyze_data_structure():
    """深入分析数据结构"""
    print("🔍 === 全新分析 encript_body.txt ===\n")
    
    with open('encript_body.txt', 'r') as f:
        data = f.read().strip()
    
    print(f"数据长度: {len(data)} 字符")
    
    # 字符集分析
    charset = sorted(set(data))
    print(f"字符集 ({len(charset)}个): {''.join(charset)}")
    
    # 检查是否是标准Base64字符集
    base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
    is_base64_compatible = all(c in base64_chars + '=' for c in data)
    print(f"是否Base64兼容: {is_base64_compatible}")
    
    # 查找数据中的模式
    print("\n🔍 === 模式分析 ===")
    
    # 1. 查找重复的长模式
    for pattern_len in [8, 12, 16, 20]:
        patterns = {}
        for i in range(len(data) - pattern_len + 1):
            pattern = data[i:i+pattern_len]
            if pattern not in patterns:
                patterns[pattern] = []
            patterns[pattern].append(i)
        
        # 找出重复的模式
        repeated = {p: pos for p, pos in patterns.items() if len(pos) > 2}
        if repeated:
            print(f"\n长度{pattern_len}的重复模式 (出现>2次):")
            sorted_patterns = sorted(repeated.items(), key=lambda x: len(x[1]), reverse=True)
            for pattern, positions in sorted_patterns[:3]:
                print(f"  '{pattern}': {len(positions)}次")
                print(f"    位置: {positions[:5]}...")
    
    return data, charset

def try_custom_base64_decode(data):
    """尝试自定义Base64解码"""
    print("\n🔐 === 尝试自定义Base64解码 ===")
    
    # 我们的字符集
    charset = sorted(set(data))
    charset_str = ''.join(charset)
    
    # 标准Base64字符集
    std_base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
    
    # 如果字符数是64，可能是Base64变体
    if len(charset) == 64:
        print(f"字符集长度为64，可能是Base64变体")
        
        # 创建映射：自定义字符集 -> 标准Base64
        mapping = {}
        for i, char in enumerate(charset_str):
            if i < len(std_base64):
                mapping[char] = std_base64[i]
        
        # 转换为标准Base64
        translated = ''.join(mapping.get(c, c) for c in data)
        
        # 尝试解码
        try:
            # 添加必要的padding
            padding = (4 - len(translated) % 4) % 4
            translated += '=' * padding
            
            decoded = base64.b64decode(translated)
            print(f"Base64解码成功!")
            return decoded
        except Exception as e:
            print(f"Base64解码失败: {e}")
    
    return None

def analyze_as_segments(data):
    """将数据作为分段结构分析"""
    print("\n📊 === 分段结构分析 ===")
    
    # 寻找可能的分隔符
    separators = []
    
    # 查找重复出现的短字符串作为分隔符
    for length in range(2, 6):
        counter = Counter()
        for i in range(len(data) - length + 1):
            substr = data[i:i+length]
            counter[substr] += 1
        
        # 找出频繁出现的模式
        common = counter.most_common(10)
        for pattern, count in common:
            if count >= 10:  # 至少出现10次
                # 检查分布
                positions = [m.start() for m in re.finditer(re.escape(pattern), data)]
                if len(positions) >= 10:
                    # 计算间距
                    distances = [positions[i+1] - positions[i] for i in range(len(positions)-1)]
                    if distances:
                        avg_dist = sum(distances) / len(distances)
                        # 如果分布相对均匀，可能是分隔符
                        if max(distances) < avg_dist * 3:
                            separators.append((pattern, count, avg_dist))
    
    if separators:
        print("可能的分隔符:")
        separators.sort(key=lambda x: x[1], reverse=True)
        for sep, count, avg_dist in separators[:5]:
            print(f"  '{sep}': {count}次, 平均间距{avg_dist:.1f}")
            
            # 尝试按此分隔符分段
            segments = data.split(sep)
            valid_segments = [s for s in segments if len(s) > 10]
            print(f"    分段数: {len(segments)}, 有效段: {len(valid_segments)}")

def check_xor_encryption(data):
    """检查是否是XOR加密"""
    print("\n🔑 === 检查XOR加密可能性 ===")
    
    # 尝试一些常见的XOR密钥
    test_keys = [
        "tongyi", "lingma", "cosy", "intellij", 
        "alibaba", "aliyun", "2.5.16"
    ]
    
    for key in test_keys:
        # XOR解密前100个字符
        result = ""
        for i in range(min(100, len(data))):
            result += chr(ord(data[i]) ^ ord(key[i % len(key)]))
        
        # 检查结果是否包含可读文本
        printable = sum(1 for c in result if 32 <= ord(c) <= 126)
        if printable > 80:  # 80%以上可打印
            print(f"密钥'{key}'可能有效:")
            print(f"  结果: {repr(result[:50])}...")

def find_json_pattern(data):
    """寻找JSON模式"""
    print("\n🎯 === 寻找JSON模式 ===")
    
    # JSON通常以{开始，以}结束
    # 在加密数据中寻找可能对应这些字符的模式
    
    # 统计字符频率
    freq = Counter(data)
    sorted_chars = sorted(freq.items(), key=lambda x: x[1], reverse=True)
    
    print("字符频率（前10）:")
    for char, count in sorted_chars[:10]:
        print(f"  '{char}': {count} ({count/len(data)*100:.1f}%)")
    
    # 在JSON中，引号(")通常是最频繁的
    # 假设最频繁的字符是引号
    most_frequent = sorted_chars[0][0]
    print(f"\n假设 '{most_frequent}' = '\"' (引号)")
    
    # 查找可能的字段模式
    # JSON字段通常是 "fieldName": 
    # 所以我们查找 X...X: 的模式，其中X是最频繁的字符
    
    pattern = f"{most_frequent}[^{most_frequent}]{{3,20}}{most_frequent}"
    matches = re.findall(pattern, data[:500])  # 只查看前500字符
    
    if matches:
        print(f"\n找到可能的字段模式:")
        for match in matches[:5]:
            print(f"  {match}")

def advanced_analysis(data):
    """高级分析"""
    print("\n🚀 === 高级分析 ===")
    
    # 1. 检查是否有明显的JSON结构特征
    # JSON中常见的字符组合
    json_patterns = [
        ('":"', '冒号引号组合'),
        ('","', '逗号引号组合'),  
        ('{"', '大括号引号组合'),
        ('"}', '引号大括号组合'),
        ('": ', '冒号空格组合'),
        (', "', '逗号空格引号组合')
    ]
    
    # 在数据中查找这些模式的加密版本
    # 假设这些模式在加密后仍然保持某种规律
    
    print("查找加密的JSON模式:")
    for pattern, desc in json_patterns:
        # 查找长度相同的重复模式
        pattern_len = len(pattern)
        counter = Counter()
        for i in range(len(data) - pattern_len + 1):
            substr = data[i:i+pattern_len]
            counter[substr] += 1
        
        # 显示最常见的
        common = counter.most_common(5)
        if common[0][1] > 5:  # 至少出现5次
            print(f"\n{desc} (长度{pattern_len})的常见模式:")
            for pat, count in common[:3]:
                print(f"  '{pat}': {count}次")

if __name__ == "__main__":
    data, charset = analyze_data_structure()
    
    # 尝试各种解密方法
    decoded = try_custom_base64_decode(data)
    
    if decoded:
        print(f"\n解码结果 (前100字节): {decoded[:100]}")
        # 保存解码结果
        with open('decoded_result.bin', 'wb') as f:
            f.write(decoded)
        print("解码结果已保存到 decoded_result.bin")
    
    analyze_as_segments(data)
    check_xor_encryption(data)
    find_json_pattern(data)
    advanced_analysis(data)
    
    print("\n💡 === 分析总结 ===")
    print("基于分析，这个加密数据：")
    print(f"1. 使用{len(charset)}个字符的字符集")
    print("2. 包含重复的模式，暗示结构化数据")
    print("3. 可能使用了:")
    print("   - 自定义的Base64编码")
    print("   - 字符替换加密")
    print("   - XOR加密")
    print("   - 或者组合加密")